home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / system-config-printer / timedops.py < prev    next >
Encoding:
Python Source  |  2009-10-19  |  6.8 KB  |  206 lines
  1. #!/usr/bin/env python
  2.  
  3. ## Copyright (C) 2008, 2009 Red Hat, Inc.
  4. ## Copyright (C) 2008, 2009 Tim Waugh <twaugh@redhat.com>
  5.  
  6. ## This program is free software; you can redistribute it and/or modify
  7. ## it under the terms of the GNU General Public License as published by
  8. ## the Free Software Foundation; either version 2 of the License, or
  9. ## (at your option) any later version.
  10.  
  11. ## This program is distributed in the hope that it will be useful,
  12. ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. ## GNU General Public License for more details.
  15.  
  16. ## You should have received a copy of the GNU General Public License
  17. ## along with this program; if not, write to the Free Software
  18. ## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20. import gobject
  21. import gtk
  22. import subprocess
  23. import threading
  24. from gettext import gettext as _
  25. from debug import *
  26.  
  27. class OperationCanceled(RuntimeError):
  28.     pass
  29.  
  30. class Timed:
  31.     def run (self):
  32.         pass
  33.  
  34.     def cancel (self):
  35.         return False
  36.  
  37. class TimedSubprocess(Timed):
  38.     def __init__ (self, timeout=60000, parent=None, show_dialog=True,
  39.                   **args):
  40.         self.subp = subprocess.Popen (**args)
  41.         self.output = dict()
  42.         self.io_source = []
  43.         self.watchers = 2
  44.         self.timeout = timeout
  45.         self.parent = parent
  46.         self.show_dialog = show_dialog
  47.         for f in [self.subp.stdout, self.subp.stderr]:
  48.             if f != None:
  49.                 source = gobject.io_add_watch (f,
  50.                                                gobject.IO_IN |
  51.                                                gobject.IO_HUP |
  52.                                                gobject.IO_ERR,
  53.                                                self.watcher)
  54.                 self.io_source.append (source)
  55.  
  56.         self.wait_window = None
  57.  
  58.     def run (self):
  59.         if self.show_dialog:
  60.             self.wait_source = gobject.timeout_add (1000,
  61.                                                     self.show_wait_window)
  62.  
  63.         self.timeout_source = gobject.timeout_add (self.timeout,
  64.                                                    self.do_timeout)
  65.         gtk.main ()
  66.         gobject.source_remove (self.timeout_source)
  67.         if self.show_dialog:
  68.             gobject.source_remove (self.wait_source)
  69.         for source in self.io_source:
  70.             gobject.source_remove (source)
  71.         if self.wait_window != None:
  72.             self.wait_window.destroy ()
  73.         return (self.output.get (self.subp.stdout, '').split ('\n'),
  74.                 self.output.get (self.subp.stderr, '').split ('\n'),
  75.                 self.subp.poll ())
  76.  
  77.     def do_timeout (self):
  78.         gtk.main_quit ()
  79.         return False
  80.  
  81.     def watcher (self, source, condition):
  82.         if condition & gobject.IO_IN:
  83.             buffer = self.output.get (source, '')
  84.             buffer += source.read ()
  85.             self.output[source] = buffer
  86.  
  87.         if condition & gobject.IO_HUP:
  88.             self.watchers -= 1
  89.             if self.watchers == 0:
  90.                 gtk.main_quit ()
  91.                 return False
  92.  
  93.         return True
  94.  
  95.     def show_wait_window (self):
  96.         wait = gtk.MessageDialog (self.parent,
  97.                                   gtk.DIALOG_MODAL |
  98.                                   gtk.DIALOG_DESTROY_WITH_PARENT,
  99.                                   gtk.MESSAGE_INFO,
  100.                                   gtk.BUTTONS_CANCEL,
  101.                                   _("Please wait"))
  102.         wait.connect ("delete_event", lambda *args: False)
  103.         wait.connect ("response", self.wait_window_response)
  104.         if self.parent:
  105.             wait.set_transient_for (self.parent)
  106.         wait.set_position (gtk.WIN_POS_CENTER_ON_PARENT)
  107.         wait.format_secondary_text (_("Gathering information"))
  108.         wait.show_all ()
  109.         self.wait_window = wait
  110.         return False
  111.  
  112.     def wait_window_response (self, dialog, response):
  113.         if response == gtk.RESPONSE_CANCEL:
  114.             self.cancel ()
  115.  
  116.     def cancel (self):
  117.         if self.watchers > 0:
  118.             debugprint ("Command canceled")
  119.             gtk.main_quit ()
  120.             self.watchers = 0
  121.  
  122.         return False
  123.  
  124. class OperationThread(threading.Thread):
  125.     def __init__ (self, target=None, args=(), kwargs={}):
  126.         threading.Thread.__init__ (self)
  127.         self.setDaemon (True)
  128.         self.target = target
  129.         self.args = args
  130.         self.kwargs = kwargs
  131.         self.exception = None
  132.         self.result = None
  133.  
  134.     def run (self):
  135.         try:
  136.             debugprint ("Calling %s" % self.target)
  137.             self.result = self.target (*self.args, **self.kwargs)
  138.             debugprint ("Done")
  139.         except Exception, e:
  140.             debugprint ("Caught exception %s" % e)
  141.             self.exception = e
  142.  
  143.     def collect_result (self):
  144.         if self.isAlive ():
  145.             # We've been canceled.
  146.             raise OperationCanceled()
  147.  
  148.         if self.exception:
  149.             raise self.exception
  150.  
  151.         return self.result
  152.  
  153. class TimedOperation(Timed):
  154.     def __init__ (self, target, args=(), kwargs={}, parent=None,
  155.                   show_dialog=False):
  156.         self.wait_window = None
  157.         self.parent = parent
  158.         self.show_dialog = show_dialog
  159.         self.thread = OperationThread (target=target,
  160.                                        args=args,
  161.                                        kwargs=kwargs)
  162.         self.thread.start ()
  163.  
  164.     def run (self):
  165.         if self.show_dialog:
  166.             wait = gtk.MessageDialog (self.parent,
  167.                                       gtk.DIALOG_MODAL |
  168.                                       gtk.DIALOG_DESTROY_WITH_PARENT,
  169.                                       gtk.MESSAGE_INFO,
  170.                                       gtk.BUTTONS_CANCEL,
  171.                                       _("Please wait"))
  172.             wait.connect ("delete_event", lambda *args: False)
  173.             wait.connect ("response", self.wait_window_response)
  174.             if self.parent:
  175.                 wait.set_transient_for (self.parent)
  176.  
  177.             wait.set_position (gtk.WIN_POS_CENTER_ON_PARENT)
  178.             wait.format_secondary_text (_("Gathering information"))
  179.             wait.show_all ()
  180.  
  181.         self.timeout_source = gobject.timeout_add (50, self.check_thread)
  182.         gtk.main ()
  183.         gobject.source_remove (self.timeout_source)
  184.         if self.show_dialog:
  185.             wait.destroy ()
  186.  
  187.         return self.thread.collect_result ()
  188.  
  189.     def check_thread (self):
  190.         if self.thread.isAlive ():
  191.             # Thread still running.
  192.             return True
  193.  
  194.         # Thread has finished.  Stop the sub-loop.
  195.         gtk.main_quit ()
  196.         return False
  197.  
  198.     def wait_window_response (self, dialog, response):
  199.         if response == gtk.RESPONSE_CANCEL:
  200.             self.cancel ()
  201.  
  202.     def cancel (self):
  203.         debugprint ("Command canceled")
  204.         gtk.main_quit ()
  205.         return False
  206.